/**
 * 视频处理工具
 * 用于处理视频格式转换和跨平台兼容性
 */

/**
 * 支持的视频格式
 */
export const SUPPORTED_FORMATS = {
  // 主要格式
  MP4: 'mp4',
  WEBM: 'webm',
  OGG: 'ogg',
  // 移动端格式
  MOV: 'mov',
  AVI: 'avi',
  // 压缩格式
  M4V: 'm4v',
  '3GP': '3gp'
}

/**
 * 跨平台兼容的视频格式优先级
 */
export const COMPATIBLE_FORMATS = [
  'mp4',  // 最佳兼容性
  'webm', // Web标准
  'ogg',  // 开源格式
  'm4v',  // Apple兼容
  'mov',  // QuickTime
  'avi',  // Windows兼容
  '3gp'   // 移动端
]

/**
 * 视频质量配置
 */
export const VIDEO_QUALITY_CONFIG = {
  // 高质量（用于重要视频）
  HIGH: {
    width: 1920,
    height: 1080,
    bitrate: 5000000, // 5Mbps
    framerate: 30
  },
  // 中等质量（默认）
  MEDIUM: {
    width: 1280,
    height: 720,
    bitrate: 2000000, // 2Mbps
    framerate: 30
  },
  // 低质量（快速上传）
  LOW: {
    width: 854,
    height: 480,
    bitrate: 1000000, // 1Mbps
    framerate: 24
  }
}

/**
 * 获取视频文件信息
 * @param {string} filePath - 视频文件路径
 * @returns {Promise<Object>} 视频信息
 */
export function getVideoInfo(filePath) {
  return new Promise((resolve, reject) => {
    // #ifdef APP-PLUS
    try {
      // 使用原生API获取视频信息
      plus.io.resolveLocalFileSystemURL(filePath, (entry) => {
        entry.file((file) => {
          // 创建video元素获取视频信息
          const video = document.createElement('video')
          video.preload = 'metadata'
          
          video.onloadedmetadata = () => {
            resolve({
              duration: video.duration,
              width: video.videoWidth,
              height: video.videoHeight,
              size: file.size,
              type: file.type,
              name: file.name,
              lastModified: file.lastModifiedDate
            })
          }
          
          video.onerror = () => {
            reject(new Error('无法读取视频信息'))
          }
          
          video.src = filePath
        })
      })
    } catch (error) {
      reject(error)
    }
    // #endif
    
    // #ifndef APP-PLUS
    // H5环境使用标准API
    const video = document.createElement('video')
    video.preload = 'metadata'
    
    video.onloadedmetadata = () => {
      resolve({
        duration: video.duration,
        width: video.videoWidth,
        height: video.videoHeight,
        size: 0, // H5环境无法直接获取文件大小
        type: 'video/mp4',
        name: 'video.mp4'
      })
    }
    
    video.onerror = () => {
      reject(new Error('无法读取视频信息'))
    }
    
    video.src = filePath
    // #endif
  })
}

/**
 * 检查视频格式是否兼容
 * @param {string} format - 视频格式
 * @returns {boolean} 是否兼容
 */
export function isCompatibleFormat(format) {
  if (!format) return false
  
  const lowerFormat = format.toLowerCase()
  return COMPATIBLE_FORMATS.includes(lowerFormat)
}

/**
 * 获取最佳视频格式
 * @param {string} originalFormat - 原始格式
 * @returns {string} 最佳格式
 */
export function getBestFormat(originalFormat) {
  if (!originalFormat) return 'mp4'
  
  const lowerFormat = originalFormat.toLowerCase()
  
  // 如果已经是兼容格式，直接返回
  if (isCompatibleFormat(lowerFormat)) {
    return lowerFormat
  }
  
  // 根据原始格式选择最佳转换格式
  const formatMap = {
    'mov': 'mp4',
    'avi': 'mp4',
    'mkv': 'mp4',
    'flv': 'mp4',
    'wmv': 'mp4',
    'mts': 'mp4',
    'm2ts': 'mp4',
    'ts': 'mp4'
  }
  
  return formatMap[lowerFormat] || 'mp4'
}

/**
 * 压缩视频
 * @param {Object} videoData - 视频数据
 * @param {Object} options - 压缩选项
 * @returns {Promise<Object>} 压缩后的视频数据
 */
export function compressVideo(videoData, options = {}) {
  return new Promise((resolve, reject) => {
    const {
      quality = 'MEDIUM',
      format = 'mp4',
      maxSize = 50 * 1024 * 1024 // 50MB
    } = options
    
    // #ifdef APP-PLUS
    try {
      // 使用原生压缩API
      plus.video.compress({
        src: videoData.tempFilePath,
        dst: videoData.tempFilePath.replace(/\.[^/.]+$/, '_compressed.mp4'),
        quality: quality.toLowerCase(),
        format: format,
        success: (result) => {
          resolve({
            ...videoData,
            tempFilePath: result.dst,
            size: result.size,
            compressed: true
          })
        },
        fail: (error) => {
          console.warn('视频压缩失败，使用原始文件:', error)
          resolve(videoData)
        }
      })
    } catch (error) {
      console.warn('视频压缩API不可用，使用原始文件:', error)
      resolve(videoData)
    }
    // #endif
    
    // #ifndef APP-PLUS
    // H5环境无法压缩，直接返回
    resolve(videoData)
    // #endif
  })
}

/**
 * 转换视频格式
 * @param {Object} videoData - 视频数据
 * @param {string} targetFormat - 目标格式
 * @returns {Promise<Object>} 转换后的视频数据
 */
export function convertVideoFormat(videoData, targetFormat = 'mp4') {
  return new Promise((resolve, reject) => {
    // #ifdef APP-PLUS
    try {
      // 使用原生转换API
      plus.video.convert({
        src: videoData.tempFilePath,
        dst: videoData.tempFilePath.replace(/\.[^/.]+$/, `_converted.${targetFormat}`),
        format: targetFormat,
        success: (result) => {
          resolve({
            ...videoData,
            tempFilePath: result.dst,
            format: targetFormat,
            converted: true
          })
        },
        fail: (error) => {
          console.warn('视频格式转换失败，使用原始文件:', error)
          resolve(videoData)
        }
      })
    } catch (error) {
      console.warn('视频转换API不可用，使用原始文件:', error)
      resolve(videoData)
    }
    // #endif
    
    // #ifndef APP-PLUS
    // H5环境无法转换，直接返回
    resolve(videoData)
    // #endif
  })
}

/**
 * 处理视频文件，确保跨平台兼容
 * @param {Object} videoData - 视频数据
 * @param {Object} options - 处理选项
 * @returns {Promise<Object>} 处理后的视频数据
 */
export async function processVideoForCrossPlatform(videoData, options = {}) {
  try {
    console.log('开始处理视频文件:', videoData)
    
    // 1. 获取视频信息
    const videoInfo = await getVideoInfo(videoData.tempFilePath)
    console.log('视频信息:', videoInfo)
    
    // 2. 检查格式兼容性
    const currentFormat = getFileExtension(videoData.tempFilePath)
    const bestFormat = getBestFormat(currentFormat)
    
    console.log('当前格式:', currentFormat, '最佳格式:', bestFormat)
    
    // 3. 如果需要转换格式
    let processedData = videoData
    if (currentFormat !== bestFormat) {
      console.log('需要转换格式:', currentFormat, '->', bestFormat)
      processedData = await convertVideoFormat(videoData, bestFormat)
    }
    
    // 4. 检查文件大小，如果需要压缩
    const maxSize = options.maxSize || 50 * 1024 * 1024 // 50MB
    if (videoInfo.size > maxSize) {
      console.log('文件过大，需要压缩:', videoInfo.size, 'bytes')
      processedData = await compressVideo(processedData, {
        quality: options.quality || 'MEDIUM',
        format: bestFormat,
        maxSize: maxSize
      })
    }
    
    // 5. 添加处理信息
    processedData.processed = true
    processedData.originalFormat = currentFormat
    processedData.targetFormat = bestFormat
    processedData.videoInfo = videoInfo
    
    console.log('视频处理完成:', processedData)
    return processedData
    
  } catch (error) {
    console.error('视频处理失败:', error)
    // 处理失败时返回原始数据
    return videoData
  }
}

/**
 * 获取文件扩展名
 * @param {string} filePath - 文件路径
 * @returns {string} 扩展名
 */
function getFileExtension(filePath) {
  if (!filePath) return ''
  const match = filePath.match(/\.([^.?]+)(\?|$)/)
  return match ? match[1].toLowerCase() : ''
}

/**
 * 验证视频文件
 * @param {Object} videoData - 视频数据
 * @returns {Object} 验证结果
 */
export function validateVideoFile(videoData) {
  const errors = []
  const warnings = []
  
  // 检查文件大小
  const maxSize = 100 * 1024 * 1024 // 100MB
  if (videoData.size > maxSize) {
    errors.push(`文件过大: ${(videoData.size / 1024 / 1024).toFixed(2)}MB，最大支持100MB`)
  }
  
  // 检查时长
  if (videoData.duration > 300) { // 5分钟
    warnings.push('视频时长超过5分钟，建议压缩')
  }
  
  // 检查格式
  const format = getFileExtension(videoData.tempFilePath)
  if (!isCompatibleFormat(format)) {
    warnings.push(`格式 ${format} 可能不兼容，建议转换为MP4`)
  }
  
  return {
    isValid: errors.length === 0,
    errors,
    warnings
  }
}
